MAYBE 150.103 H-Termination proof of /home/matraf/haskell/eval_FullyBlown_Fast/List.hs
H-Termination of the given Haskell-Program with start terms could not be shown:



↳ HASKELL
  ↳ LR

mainModule List
  ((group :: [Float]  ->  [[Float]]) :: [Float]  ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy _ [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = (\(ys,_) ->ys) vv10
zs = (\(_,zs) ->zs) vv10


module Maybe where
  import qualified List
import qualified Prelude



Lambda Reductions:
The following Lambda expression
\(_,zs)→zs

is transformed to
zs0 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys0 (ys,_) = ys

The following Lambda expression
\(_,zs)→zs

is transformed to
zs1 (_,zs) = zs

The following Lambda expression
\(ys,_)→ys

is transformed to
ys1 (ys,_) = ys



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR

mainModule List
  ((group :: [Float]  ->  [[Float]]) :: [Float]  ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy _ [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = ys0 vv10
ys0 (ys,_) = ys
zs = zs0 vv10
zs0 (_,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Replaced joker patterns by fresh variables and removed binding patterns.
Binding Reductions:
The bind variable of the following binding Pattern
xs@(ww : wx)

is replaced by the following term
ww : wx



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR

mainModule List
  ((group :: [Float]  ->  [[Float]]) :: [Float]  ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy vw [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = ys0 vv10
ys0 (ys,vx) = ys
zs = zs0 vv10
zs0 (vy,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Cond Reductions:
The following Function with conditions
undefined 
 | False
 = undefined

is transformed to
undefined  = undefined1

undefined0 True = undefined

undefined1  = undefined0 False

The following Function with conditions
span p [] = ([],[])
span p (ww : wx)
 | p ww
 = (ww : ys,zs)
 | otherwise
 = ([],ww : wx)
where 
vu43  = span p wx
ys  = ys1 vu43
ys1 (ys,wz) = ys
zs  = zs1 vu43
zs1 (wy,zs) = zs

is transformed to
span p [] = span3 p []
span p (ww : wx) = span2 p (ww : wx)

span2 p (ww : wx) = 
span1 p ww wx (p ww)
where 
span0 p ww wx True = ([],ww : wx)
span1 p ww wx True = (ww : ys,zs)
span1 p ww wx False = span0 p ww wx otherwise
vu43  = span p wx
ys  = ys1 vu43
ys1 (ys,wz) = ys
zs  = zs1 vu43
zs1 (wy,zs) = zs

span3 p [] = ([],[])
span3 xx xy = span2 xx xy



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed

mainModule List
  ((group :: [Float]  ->  [[Float]]) :: [Float]  ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy vw [] = []
groupBy eq (x : xs) = 
(x : ys) : groupBy eq zs where 
vv10 = span (eq x) xs
ys = ys0 vv10
ys0 (ys,vx) = ys
zs = zs0 vv10
zs0 (vy,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Let/Where Reductions:
The bindings of the following Let/Where expression
(x : ys) : groupBy eq zs
where 
vv10  = span (eq x) xs
ys  = ys0 vv10
ys0 (ys,vx) = ys
zs  = zs0 vv10
zs0 (vy,zs) = zs

are unpacked to the following functions on top level
groupByYs xz yu yv = groupByYs0 xz yu yv (groupByVv10 xz yu yv)

groupByVv10 xz yu yv = span (xz yu) yv

groupByZs xz yu yv = groupByZs0 xz yu yv (groupByVv10 xz yu yv)

groupByZs0 xz yu yv (vy,zs) = zs

groupByYs0 xz yu yv (ys,vx) = ys

The bindings of the following Let/Where expression
span1 p ww wx (p ww)
where 
span0 p ww wx True = ([],ww : wx)
span1 p ww wx True = (ww : ys,zs)
span1 p ww wx False = span0 p ww wx otherwise
vu43  = span p wx
ys  = ys1 vu43
ys1 (ys,wz) = ys
zs  = zs1 vu43
zs1 (wy,zs) = zs

are unpacked to the following functions on top level
span2Vu43 yw yx = span yw yx

span2Span1 yw yx p ww wx True = (ww : span2Ys yw yx,span2Zs yw yx)
span2Span1 yw yx p ww wx False = span2Span0 yw yx p ww wx otherwise

span2Ys1 yw yx (ys,wz) = ys

span2Zs yw yx = span2Zs1 yw yx (span2Vu43 yw yx)

span2Ys yw yx = span2Ys1 yw yx (span2Vu43 yw yx)

span2Span0 yw yx p ww wx True = ([],ww : wx)

span2Zs1 yw yx (wy,zs) = zs



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow

mainModule List
  (group :: [Float]  ->  [[Float]])

module List where
  import qualified Maybe
import qualified Prelude

  group :: Eq a => [a]  ->  [[a]]
group = groupBy (==)

  groupBy :: (a  ->  a  ->  Bool)  ->  [a]  ->  [[a]]
groupBy vw [] = []
groupBy eq (x : xs) = (x : groupByYs eq x xs) : groupBy eq (groupByZs eq x xs)

  
groupByVv10 xz yu yv = span (xz yu) yv

  
groupByYs xz yu yv = groupByYs0 xz yu yv (groupByVv10 xz yu yv)

  
groupByYs0 xz yu yv (ys,vx) = ys

  
groupByZs xz yu yv = groupByZs0 xz yu yv (groupByVv10 xz yu yv)

  
groupByZs0 xz yu yv (vy,zs) = zs


module Maybe where
  import qualified List
import qualified Prelude



Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs1(yy15, yy180, yy181) → new_span2Zs(yy15, yy181)
new_span2Zs(yy15, :(yy180, yy181)) → new_span2Zs1(yy15, yy180, yy181)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs10(yy15, yy1600, yy180, yy181) → new_span2Zs0(yy15, yy1600, yy181)
new_span2Zs0(yy15, yy1600, :(yy180, yy181)) → new_span2Zs10(yy15, yy1600, yy180, yy181)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs11(yy52, yy53, yy540, yy541) → new_span2Zs2(yy52, yy53, yy541)
new_span2Zs2(yy52, yy53, :(yy540, yy541)) → new_span2Zs11(yy52, yy53, yy540, yy541)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Ys(yy10, :(yy130, yy131)) → new_span2Ys1(yy10, yy130, yy131)
new_span2Ys1(yy10, yy130, yy131) → new_span2Ys(yy10, yy131)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primPlusNat(Succ(yy10500), Succ(yy3100000)) → new_primPlusNat(yy10500, yy3100000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat(Succ(yy300000), yy310000) → new_primMulNat(yy300000, yy310000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primMulNat0(Succ(yy19000), Succ(yy37000)) → new_primMulNat0(yy19000, Succ(yy37000))

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_primEqNat(Succ(yy209900), Succ(yy210600)) → new_primEqNat(yy209900, yy210600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs3(:(yy3110, yy3111)) → new_span2Zs12(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Zero)), yy3110))
new_span2Zs12(yy3110, yy3111, True) → new_span2Zs3(yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs3(:(yy3110, yy3111)) → new_span2Zs12(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Zero)), yy3110))
new_span2Zs12(yy3110, yy3111, True) → new_span2Zs3(yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Ys0(yy21, :(yy220, yy221)) → new_span2Ys10(yy21, yy220, yy221, new_primEqFloat(yy21, yy220))
new_span2Ys10(yy21, yy220, yy221, True) → new_span2Ys0(yy21, yy221)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs4(:(yy3110, yy3111)) → new_span2Zs13(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Zero)), yy3110))
new_span2Zs13(yy3110, yy3111, True) → new_span2Zs4(yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs4(:(yy3110, yy3111)) → new_span2Zs13(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Zero)), yy3110))
new_span2Zs13(yy3110, yy3111, True) → new_span2Zs4(yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs14(yy3110, yy3111, True) → new_span2Zs5(yy3111)
new_span2Zs5(:(yy3110, yy3111)) → new_span2Zs14(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs14(yy3110, yy3111, True) → new_span2Zs5(yy3111)
new_span2Zs5(:(yy3110, yy3111)) → new_span2Zs14(yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs6(:(yy3110, yy3111)) → new_span2Zs15(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Zero)), yy3110))
new_span2Zs15(yy3110, yy3111, True) → new_span2Zs6(yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs6(:(yy3110, yy3111)) → new_span2Zs15(yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Zero)), yy3110))
new_span2Zs15(yy3110, yy3111, True) → new_span2Zs6(yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs7(yy30100, :(yy3110, yy3111)) → new_span2Zs16(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Succ(yy30100))), yy3110))
new_span2Zs16(yy30100, yy3110, yy3111, True) → new_span2Zs7(yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs7(yy30100, :(yy3110, yy3111)) → new_span2Zs16(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Neg(Succ(yy30100))), yy3110))
new_span2Zs16(yy30100, yy3110, yy3111, True) → new_span2Zs7(yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs17(yy30100, yy3110, yy3111, True) → new_span2Zs8(yy30100, yy3111)
new_span2Zs8(yy30100, :(yy3110, yy3111)) → new_span2Zs17(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs17(yy30100, yy3110, yy3111, True) → new_span2Zs8(yy30100, yy3111)
new_span2Zs8(yy30100, :(yy3110, yy3111)) → new_span2Zs17(yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs18(yy30000, yy3110, yy3111, True) → new_span2Zs9(yy30000, yy3111)
new_span2Zs9(yy30000, :(yy3110, yy3111)) → new_span2Zs18(yy30000, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs18(yy30000, yy3110, yy3111, True) → new_span2Zs9(yy30000, yy3111)
new_span2Zs9(yy30000, :(yy3110, yy3111)) → new_span2Zs18(yy30000, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs19(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs110(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs110(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs19(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs19(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs110(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs110(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs19(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs0(yy76, yy7700, yy78, yy7900, yy80, Succ(yy119400), Succ(yy123600)) → new_groupByZs0(yy76, yy7700, yy78, yy7900, yy80, yy119400, yy123600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs00(yy70, yy7100, yy72, yy7300, yy74, Succ(yy64400), Succ(yy65800)) → new_groupByZs00(yy70, yy7100, yy72, yy7300, yy74, yy64400, yy65800)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs0(yy45, yy4600, yy47, yy4800, yy49, Succ(yy37300), Succ(yy40900)) → new_groupByYs0(yy45, yy4600, yy47, yy4800, yy49, yy37300, yy40900)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs00(yy90, yy9100, yy92, yy9300, yy94, Succ(yy21100), Succ(yy24500)) → new_groupByYs00(yy90, yy9100, yy92, yy9300, yy94, yy21100, yy24500)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs20(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs111(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs111(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs20(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs20(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs111(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Neg(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs111(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs20(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs01(yy76, yy7700, yy78, yy7900, yy80, Succ(yy119400), Succ(yy123400)) → new_groupByZs01(yy76, yy7700, yy78, yy7900, yy80, yy119400, yy123400)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs02(yy70, yy7100, yy72, yy7300, yy74, Succ(yy64400), Succ(yy65600)) → new_groupByZs02(yy70, yy7100, yy72, yy7300, yy74, yy64400, yy65600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs01(yy45, yy4600, yy47, yy4800, yy49, Succ(yy37300), Succ(yy40700)) → new_groupByYs01(yy45, yy4600, yy47, yy4800, yy49, yy37300, yy40700)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs02(yy90, yy9100, yy92, yy9300, yy94, Succ(yy21100), Succ(yy24300)) → new_groupByYs02(yy90, yy9100, yy92, yy9300, yy94, yy21100, yy24300)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs112(yy30100, yy3110, yy3111, True) → new_span2Zs21(yy30100, yy3111)
new_span2Zs21(yy30100, :(yy3110, yy3111)) → new_span2Zs112(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs112(yy30100, yy3110, yy3111, True) → new_span2Zs21(yy30100, yy3111)
new_span2Zs21(yy30100, :(yy3110, yy3111)) → new_span2Zs112(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Neg(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs113(yy30100, yy3110, yy3111, True) → new_span2Zs22(yy30100, yy3111)
new_span2Zs22(yy30100, :(yy3110, yy3111)) → new_span2Zs113(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs113(yy30100, yy3110, yy3111, True) → new_span2Zs22(yy30100, yy3111)
new_span2Zs22(yy30100, :(yy3110, yy3111)) → new_span2Zs113(yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Zero), Pos(Succ(yy30100))), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs114(yy30000, yy3110, yy3111, True) → new_span2Zs23(yy30000, yy3111)
new_span2Zs23(yy30000, :(yy3110, yy3111)) → new_span2Zs114(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs114(yy30000, yy3110, yy3111, True) → new_span2Zs23(yy30000, yy3111)
new_span2Zs23(yy30000, :(yy3110, yy3111)) → new_span2Zs114(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs115(yy30000, yy3110, yy3111, True) → new_span2Zs24(yy30000, yy3111)
new_span2Zs24(yy30000, :(yy3110, yy3111)) → new_span2Zs115(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs115(yy30000, yy3110, yy3111, True) → new_span2Zs24(yy30000, yy3111)
new_span2Zs24(yy30000, :(yy3110, yy3111)) → new_span2Zs115(yy30000, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Zero)), yy3110))

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs25(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs116(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs116(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs25(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs25(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs116(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Neg(Succ(yy30100))), yy3110))
new_span2Zs116(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs25(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs03(yy63, yy6400, yy65, yy6600, yy67, Succ(yy93800), Succ(yy98000)) → new_groupByZs03(yy63, yy6400, yy65, yy6600, yy67, yy93800, yy98000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs04(yy57, yy5800, yy59, yy6000, yy61, Succ(yy55100), Succ(yy56500)) → new_groupByZs04(yy57, yy5800, yy59, yy6000, yy61, yy55100, yy56500)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs03(yy97, yy9800, yy99, yy10000, yy101, Succ(yy1200), Succ(yy137000)) → new_groupByYs03(yy97, yy9800, yy99, yy10000, yy101, yy1200, yy137000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs04(yy84, yy8500, yy86, yy8700, yy88, Succ(yy74300), Succ(yy76600)) → new_groupByYs04(yy84, yy8500, yy86, yy8700, yy88, yy74300, yy76600)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs26(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs117(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs117(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs26(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt4(Zero) → True
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqInt5(Zero) → True
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primEqInt4(Succ(yy21090)) → False
new_primEqInt3(yy20990, yy2107) → False
new_primEqFloat(Float(Neg(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt(Succ(yy21080)) → False
new_primPlusNat0(Zero, Zero) → Zero
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Zero) → True
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt2(yy20990, Zero) → False
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt(Zero) → True
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ UsableRulesProof
                          ↳ QDP
                            ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_span2Zs26(yy30000, yy30100, :(yy3110, yy3111)) → new_span2Zs117(yy30000, yy30100, yy3110, yy3111, new_primEqFloat(Float(Pos(Succ(yy30000)), Pos(Succ(yy30100))), yy3110))
new_span2Zs117(yy30000, yy30100, yy3110, yy3111, True) → new_span2Zs26(yy30000, yy30100, yy3111)

The TRS R consists of the following rules:

new_primEqFloat(Float(Pos(yy1900), yy191), Float(Neg(yy3700), yy371)) → new_primEqInt1(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primEqFloat(Float(Pos(yy1900), yy191), Float(Pos(yy3700), yy371)) → new_primEqInt0(new_primMulNat1(yy1900, yy3700), yy191, yy371)
new_primMulNat1(Succ(yy19000), Succ(yy37000)) → new_primPlusNat0(new_primMulNat1(yy19000, Succ(yy37000)), Succ(yy37000))
new_primMulNat1(Succ(yy19000), Zero) → Zero
new_primMulNat1(Zero, Succ(yy37000)) → Zero
new_primMulNat1(Zero, Zero) → Zero
new_primEqInt0(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt4(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Neg(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Pos(yy3710)) → new_primEqInt3(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt(new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Neg(yy1910), Neg(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt0(Succ(yy20990), Pos(yy1910), Pos(yy3710)) → new_primEqInt2(yy20990, new_primMulNat1(yy1910, yy3710))
new_primEqInt2(yy20990, Succ(yy21060)) → new_primEqNat0(yy20990, yy21060)
new_primEqInt2(yy20990, Zero) → False
new_primEqNat0(Succ(yy209900), Succ(yy210600)) → new_primEqNat0(yy209900, yy210600)
new_primEqNat0(Zero, Zero) → True
new_primEqNat0(Succ(yy209900), Zero) → False
new_primEqNat0(Zero, Succ(yy210600)) → False
new_primEqInt(Succ(yy21080)) → False
new_primEqInt(Zero) → True
new_primEqInt3(yy20990, yy2107) → False
new_primEqInt4(Zero) → True
new_primEqInt4(Succ(yy21090)) → False
new_primPlusNat0(Succ(yy10500), Succ(yy3100000)) → Succ(Succ(new_primPlusNat0(yy10500, yy3100000)))
new_primPlusNat0(Zero, Succ(yy3100000)) → Succ(yy3100000)
new_primPlusNat0(Zero, Zero) → Zero
new_primPlusNat0(Succ(yy10500), Zero) → Succ(yy10500)
new_primEqInt1(Succ(yy21010), Pos(yy1910), Pos(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Neg(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Neg(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Neg(yy1910), Pos(yy3710)) → new_primEqInt8(new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Pos(yy1910), Neg(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Pos(yy3710)) → new_primEqInt7(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Succ(yy21010), Neg(yy1910), Neg(yy3710)) → new_primEqInt6(yy21010, new_primMulNat1(yy1910, yy3710))
new_primEqInt1(Zero, Pos(yy1910), Pos(yy3710)) → new_primEqInt5(new_primMulNat1(yy1910, yy3710))
new_primEqInt5(Zero) → True
new_primEqInt5(Succ(yy21120)) → False
new_primEqInt6(yy21010, yy2110) → False
new_primEqInt7(yy21010, Succ(yy21110)) → new_primEqNat0(yy21010, yy21110)
new_primEqInt7(yy21010, Zero) → False
new_primEqInt8(Succ(yy21130)) → False
new_primEqInt8(Zero) → True

The set Q consists of the following terms:

new_primEqInt5(Zero)
new_primEqInt3(x0, x1)
new_primEqFloat(Float(Neg(x0), x1), Float(Neg(x2), x3))
new_primEqNat0(Succ(x0), Zero)
new_primMulNat1(Zero, Succ(x0))
new_primMulNat1(Zero, Zero)
new_primEqNat0(Succ(x0), Succ(x1))
new_primEqInt0(Zero, Neg(x0), Neg(x1))
new_primEqInt1(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt1(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Neg(x1), Neg(x2))
new_primPlusNat0(Succ(x0), Succ(x1))
new_primEqInt7(x0, Succ(x1))
new_primEqInt1(Succ(x0), Neg(x1), Neg(x2))
new_primEqInt7(x0, Zero)
new_primEqInt1(Succ(x0), Pos(x1), Pos(x2))
new_primEqInt2(x0, Zero)
new_primEqInt1(Zero, Neg(x0), Neg(x1))
new_primEqInt2(x0, Succ(x1))
new_primEqInt4(Succ(x0))
new_primEqNat0(Zero, Succ(x0))
new_primEqInt1(Zero, Pos(x0), Neg(x1))
new_primEqInt1(Zero, Neg(x0), Pos(x1))
new_primPlusNat0(Zero, Succ(x0))
new_primEqNat0(Zero, Zero)
new_primEqInt6(x0, x1)
new_primEqInt0(Succ(x0), Neg(x1), Pos(x2))
new_primEqInt0(Succ(x0), Pos(x1), Neg(x2))
new_primEqInt0(Zero, Pos(x0), Pos(x1))
new_primEqInt8(Zero)
new_primEqFloat(Float(Pos(x0), x1), Float(Neg(x2), x3))
new_primEqFloat(Float(Neg(x0), x1), Float(Pos(x2), x3))
new_primEqInt0(Succ(x0), Pos(x1), Pos(x2))
new_primPlusNat0(Succ(x0), Zero)
new_primEqInt(Succ(x0))
new_primMulNat1(Succ(x0), Zero)
new_primEqInt5(Succ(x0))
new_primEqFloat(Float(Pos(x0), x1), Float(Pos(x2), x3))
new_primEqInt(Zero)
new_primEqInt4(Zero)
new_primEqInt1(Zero, Pos(x0), Pos(x1))
new_primPlusNat0(Zero, Zero)
new_primEqInt8(Succ(x0))
new_primEqInt0(Zero, Neg(x0), Pos(x1))
new_primEqInt0(Zero, Pos(x0), Neg(x1))
new_primMulNat1(Succ(x0), Succ(x1))

We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs05(yy63, yy6400, yy65, yy6600, yy67, Succ(yy93800), Succ(yy97800)) → new_groupByZs05(yy63, yy6400, yy65, yy6600, yy67, yy93800, yy97800)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByZs06(yy57, yy5800, yy59, yy6000, yy61, Succ(yy55100), Succ(yy56300)) → new_groupByZs06(yy57, yy5800, yy59, yy6000, yy61, yy55100, yy56300)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs05(yy97, yy9800, yy99, yy10000, yy101, Succ(yy1190), Succ(yy135000)) → new_groupByYs05(yy97, yy9800, yy99, yy10000, yy101, yy1190, yy135000)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ QDPSizeChangeProof
                      ↳ QDP
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupByYs06(yy84, yy8500, yy86, yy8700, yy88, Succ(yy74300), Succ(yy76400)) → new_groupByYs06(yy84, yy8500, yy86, yy8700, yy88, yy74300, yy76400)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ NonTerminationProof
                  ↳ Narrow

Q DP problem:
The TRS P consists of the following rules:

new_groupBy → new_groupBy

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We used the non-termination processor [17] to show that the DP problem is infinite.
Found a loop by semiunifying a rule from P directly.

The TRS P consists of the following rules:

new_groupBy → new_groupBy

The TRS R consists of the following rules:none


s = new_groupBy evaluates to t =new_groupBy

Thus s starts an infinite chain as s semiunifies with t with the following substitutions:




Rewriting sequence

The DP semiunifies directly so there is only one rewrite step from new_groupBy to new_groupBy.




Haskell To QDPs


↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof
                      ↳ QDP

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ HASKELL
  ↳ LR
    ↳ HASKELL
      ↳ BR
        ↳ HASKELL
          ↳ COR
            ↳ HASKELL
              ↳ LetRed
                ↳ HASKELL
                  ↳ Narrow
                  ↳ Narrow
                    ↳ AND
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                      ↳ QDP
                        ↳ PisEmptyProof

Q DP problem:
P is empty.
R is empty.
Q is empty.
We have to consider all (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.